﻿using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.SharePoint;
using MS.InformationManagement.DAL.RecordCenter;
using MS.InformationManagement.DAL.DocumentCenter;
using System.Text;
using System.Threading;
using MS.InformationManagement.Support.Constants;
using MS.InformationManagement.Support;

namespace MS.InformationManagement.BLL.RecordCenter
{
    public class ListLoaderBLL
    {
        public static string LoadFileIntoBackdropList(System.IO.Stream fileStream, char[] separator)
        {
            SPList targetList = null;
            SPListItem parentItem = null;
            string currentLine = string.Empty;
            int index = 1;
            StringBuilder error = new StringBuilder();
            bool iterationOk;
            List<FondosFondo> loadedElements = new List<FondosFondo>();

            using (DataContext ctx = new DataContext(SPContext.Current.Web.Url))
            {
                using (System.IO.StreamReader reader = new System.IO.StreamReader(fileStream,Encoding.Default))
                {
                    reader.ReadLine();
                    targetList = SPContext.Current.Web.Lists.TryGetList(GlobalConstants.LIST_BIBLIOTECA_FONDO);
                    while (!reader.EndOfStream)
                    {
                        parentItem = null;
                        iterationOk = true;
                        currentLine = reader.ReadLine();
                        string[] splitedLine = currentLine.Split(separator);

                        if (splitedLine.Length == 4)
                        {
                            double vRet = 0;
                            bool canConvert = double.TryParse(splitedLine[2].ToString(), out vRet);
                           

                            FondosFondo entity = new FondosFondo
                            {
                                Title = splitedLine[0] == null ? string.Empty : splitedLine[0],
                                Código = splitedLine[1] == null ? string.Empty : splitedLine[1],
                                VersiónTablaDeRetención =  canConvert == true ? Convert.ToDouble(splitedLine[2]) : new Nullable<double>()
                            };
                            if (string.IsNullOrEmpty(splitedLine[0]))
                            {
                                error.Append(string.Format("El nombre del fondo no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }

                            if (string.IsNullOrEmpty(splitedLine[1]))
                            {
                                error.Append(string.Format("El codigo del fondo no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }
                            if (string.IsNullOrEmpty(splitedLine[2]))
                            {
                                error.Append(string.Format("La versión de la tabla de retención no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }
                            if (canConvert != true)
                            {
                                error.Append(string.Format("El formato de La versión de la tabla de retenció es incorrecto, (fila {0})<br/>", index));
                                iterationOk = false;
                            }

                            if (ctx.Fondos.Count(backdrop => backdrop.Title.Equals(splitedLine[0].ToUpper())) > 0)
                            {
                                error.Append(string.Format("Ya existe un fondo con el nombre {0}, (fila {1})<br/>", splitedLine[0], index));
                                iterationOk = false;
                            }
                          
                            if (loadedElements.Count(backdrop => backdrop.Title.Equals(entity.Title)) > 0)
                            {
                                error.Append(string.Format("Ya existe una fondo con el nombre {0} en el documento (fila {1})<br/>"
                                    , entity.Title, index));
                                iterationOk = false;
                            }

                            if (ctx.Fondos.Count(backdrop => backdrop.Código.Equals(splitedLine[1].ToUpper())) > 0)
                            {
                                error.Append(string.Format("Ya existe un fondo con el codigo {0}, (fila {1})<br/>", splitedLine[1], index));
                                iterationOk = false;
                            }
                         
                            if (loadedElements.Count(backdrop => backdrop.Código.Equals(entity.Código)) > 0)
                            {
                                error.Append(string.Format("Ya existe una fondo con el Código {0} en el documento (fila {1})<br/>"
                                    , entity.Código, index));
                                iterationOk = false;
                            }

                            if (!string.IsNullOrEmpty(splitedLine[3]))
                            {
                                try
                                {
                                    parentItem = GetParent(splitedLine[3], targetList);
                                    if (parentItem == null)
                                    {
                                        error.Append(string.Format("No existe un fondo padre con el título {0}, (fila {1})<br/>", splitedLine[3], index));
                                        iterationOk = false;
                                    }
                                }
                                catch (Exception)
                                {
                                    error.Append(string.Format("Caracteres inválidos en el fondo padre {0}, (fila {1})<br/>", splitedLine[3], index));
                                    iterationOk = false;
                                }
                                //entity.FondoAlQuePertenece = ctx.Fondos.SingleOrDefault(backdrop => backdrop.Title.Equals(splitedLine[3]));
                            }
                           

                            if (iterationOk)
                            {
                                loadedElements.Add(entity);
                                AddBackdrop(splitedLine[0], splitedLine[1], splitedLine[2], parentItem, targetList);
                                //ctx.Fondos.InsertOnSubmit(entity);
                                //ctx.SubmitChanges();
                            }

                        }
                        else { error.Append(string.Format("El formato del archivo es inválido. Error en la fila {0}<br/>", index)); }
                        index++;
                    }
                }

            }

            return error.ToString();
        }

        public static string LoadFileIntoSectionList(System.IO.Stream fileStream, char[] separator)
        {
            string currentLine = string.Empty;
            StringBuilder error = new StringBuilder();
            int index = 1;
            bool iterationOk;
            SPListItem parentItem = null;
            SPList targetList = null;
            List<SeccionesSeccion> loadedElements =new List<SeccionesSeccion>();
            using (DataContext ctx = new DataContext(SPContext.Current.Web.Url))
            {
                using (System.IO.StreamReader reader = new System.IO.StreamReader(fileStream,Encoding.Default))
                {
                    
                    reader.ReadLine();
                    targetList = SPContext.Current.Web.Lists.TryGetList(GlobalConstants.LIST_BIBLIOTECA_SECCION);
                    while (!reader.EndOfStream)
                    {
                        parentItem = null;
                        iterationOk = true;
                        currentLine = reader.ReadLine();
                        string[] splitedLine = currentLine.Split(separator);

                        if (splitedLine.Length == 4)
                        {
                            int userID = 0;
                            try
                            {
                                userID = SPContext.Current.Web.EnsureUser(splitedLine[2]).ID;
                            }
                            catch (Exception ex)
                            {
                                iterationOk = false;
                                error.Append(string.Format("El usuario no existe. Error en la fila {0}<br/>", index));
                            }
                            SeccionesSeccion entity = new SeccionesSeccion
                            {
                                Title = splitedLine[0] == null ? string.Empty : splitedLine[0],
                                Código = splitedLine[1] == null ? string.Empty : splitedLine[1]
                            };
                            
                            if (string.IsNullOrEmpty(splitedLine[0]))
                            {
                                error.Append(string.Format("El nombre de la sección no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }
                            if (string.IsNullOrEmpty(splitedLine[1]))
                            {
                                error.Append(string.Format("El codigo de la sección no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }

                            if (ctx.Secciones.Count(seccion => seccion.Title.Equals(entity.Title)) > 0)
                            {
                                error.Append(string.Format("Ya existe una sección con el nombre {0}, (fila {1})<br/>", entity.Title, index));
                                iterationOk = false;
                            }
                            
                            if (loadedElements.Count(seccion => seccion.Title.Equals(entity.Title)) > 0)
                            {
                                error.Append(string.Format("Ya existe una sección con el nombre {0} en el documento (fila {1})<br/>"
                                    , entity.Title, index));
                                iterationOk = false;
                            }

                            if (ctx.Secciones.Count(seccion => seccion.Código.Equals(entity.Código)) > 0)
                            {
                                error.Append(string.Format("Ya existe una sección con el código {0}, (fila {1})<br/>", splitedLine[1], index));
                                iterationOk = false;
                            }
                            
                            if (loadedElements.Count(seccion => seccion.Código.Equals(entity.Código)) > 0)
                            {
                                error.Append(string.Format("Ya existe una sección con el código {0} en el documento (fila {1})<br/>"
                                    , entity.Código, index));
                                iterationOk = false;
                            }

                            if (!string.IsNullOrEmpty(splitedLine[3]))
                            {
                                try
                                {
                                    parentItem = GetParent(splitedLine[3], targetList);
                                    if (parentItem == null)
                                    {
                                        error.Append(string.Format("No se encuentra un sección padre con nombre {0}, (fila {1})<br/>", splitedLine[3], index));
                                        iterationOk = false;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    
                                    error.Append(string.Format("Caracteres inválidos en la sección padre {0}, (fila {1})<br/>", splitedLine[3], index));
                                    iterationOk = false;
                                }
                                
                            }
                            

                            if (iterationOk)
                            {
                                loadedElements.Add(entity);
                                AddSection(splitedLine[0], splitedLine[1], parentItem, userID, targetList);
                            }


                        }
                        else { error.Append(string.Format("El formato del archivo es inválido. Error en la fila {0}<br/>", index)); }
                        index++;
                    }
                }
            }
            return error.ToString();
        }

        public static string LoadFileIntoSeriesList(System.IO.Stream fileStream, char[] separator)
        {
            List<Serie> loadedElements = new List<Serie>();
            string currentLine = string.Empty;
            int index = 1;
            StringBuilder error = new StringBuilder();
            bool iterationOk;

            using (DataContext ctx = new DataContext(SPContext.Current.Web.Url))
            {
                using (System.IO.StreamReader reader = new System.IO.StreamReader(fileStream,Encoding.Default))
                {
                    reader.ReadLine();
                    while (!reader.EndOfStream)
                    {
                        iterationOk = true;
                        currentLine = reader.ReadLine();
                        string[] splitedLine = currentLine.Split(separator);

                        if (splitedLine.Length == 2)
                        {
                            Serie entity = new Serie
                            {
                                Title = splitedLine[0] == null ? string.Empty : splitedLine[0],
                                Código = splitedLine[1] == null ? string.Empty : splitedLine[1]
                            };

                            if (String.IsNullOrEmpty(entity.Title))
                            {
                                error.Append(string.Format("El nombre de la serie no puede ser vacio, (fila {0})<br/>",index));
                                iterationOk = false;
                            }
                            if (String.IsNullOrEmpty(entity.Código))
                            {
                                error.Append(string.Format("El codigo de la serie no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }

                            if (ctx.Series.Count(serie => serie.Title.Equals(entity.Title)) > 0)
                            {
                                error.Append(string.Format("Ya existe una serie con el nombre {0}, (fila {1})<br/>", entity.Title, index));
                                iterationOk = false;
                            }
                            
                            if (loadedElements.Count(serie => serie.Title.Equals(entity.Title)) > 0)
                            {
                                error.Append(string.Format("Ya existe una serie con el nombre {0} en el documento (fila {1})<br/>"
                                    , entity.Title, index));
                                iterationOk = false;
                            }

                            if (ctx.Series.Count(serie => serie.Código.Equals(entity.Código)) > 0)
                            {
                                error.Append(string.Format("Ya existe una serie con el código {0}, (fila {1})<br/>", entity.Código, index));
                                iterationOk = false;
                            }
                            
                            if (loadedElements.Count(serie => serie.Código.Equals(entity.Código)) > 0)
                            {
                                error.Append(string.Format("Ya existe una serie con el código {0} en el documento (fila {1})<br/>"
                                    , entity.Código, index));
                                iterationOk = false;
                            }

                            if (iterationOk)
                            {
                                loadedElements.Add(entity);
                                ctx.Series.InsertOnSubmit(entity);
                                ctx.SubmitChanges();
                            }
                        }
                        else { error.Append(string.Format("El formato del archivo es inválido. Error en la linea {0}<br/>", index)); }
                        index++;
                    }
                }
            }
            return error.ToString();
        }

        public static string LoadFileIntoSubSeriesList(System.IO.Stream fileStream, char[] separator)
        {
            List<Subserie> loadedElements = new List<Subserie>();
            string currentLine = string.Empty;
            int index = 1;
            bool iterationOk;
            StringBuilder error = new StringBuilder();

            using (DataContext ctx = new DataContext(SPContext.Current.Web.Url))
            {
                using (System.IO.StreamReader reader = new System.IO.StreamReader(fileStream,Encoding.Default))
                {
                    reader.ReadLine();
                    

                    while (!reader.EndOfStream)
                    {
                        iterationOk = true;
                        currentLine = reader.ReadLine();
                        string[] splitedLine = currentLine.Split(separator);

                        if (splitedLine.Length == 11)
                        {
                            Serie relatedParentEntity = null;
                            Subserie entity = null;
                            if (!string.IsNullOrEmpty(splitedLine[10]))
                            {
                                relatedParentEntity = ctx.Series.SingleOrDefault(serie => serie.Title.Equals(splitedLine[10]));
                                if (relatedParentEntity == default(Serie))
                                {
                                    error.Append(string.Format("La serie con nombre {0} no existe, (fila {1})<br/>", splitedLine[10], index));
                                    iterationOk = false;
                                }
                            }
                            long tr = 0;
                            bool canConvertres = false;
                            bool canConverttrc = false;
                            bool canConverttrg = false;
                            if (!string.IsNullOrEmpty(splitedLine[2]))
                            {
                                canConvertres = long.TryParse(splitedLine[2], out tr);
                                if (canConvertres != true)
                                {
                                    error.Append(string.Format("Error en el Formato del tiempo de respuesta de la subserie, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }
                            }

                            if (string.IsNullOrEmpty(splitedLine[3]))
                            {
                                error.Append(string.Format("El tiempo de retención en el archivo central de la subserie no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }
                            else
                            {
                                canConverttrc = long.TryParse(splitedLine[3], out tr);
                                if (canConverttrc != true)
                                {
                                    error.Append(string.Format("El tiempo de retención en el archivo central de la subserie no puede ser vacio, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }
                            }

                            if (string.IsNullOrEmpty(splitedLine[4]))
                            {
                                error.Append(string.Format("El tiempo de retención en el archivo de gestión de la subserie no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }
                            else
                            {
                                canConverttrg = long.TryParse(splitedLine[4], out tr);
                                if (canConverttrg != true)
                                {
                                    error.Append(string.Format("El tiempo de retención en el archivo de gestión de la subserie no puede ser vacio, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }
                            }
                            entity = new Subserie
                            {
                                Title = splitedLine[0] == null ? string.Empty : splitedLine[0],
                                Código = splitedLine[1] == null ? string.Empty : splitedLine[1],
                                TiempoDeRespuesta = canConvertres == true? Convert.ToDouble(splitedLine[2]): new Nullable<double>(),
                                TiempoDeRetenciónEnArchivoCentral = canConverttrc == true? Convert.ToDouble(splitedLine[3]):new Nullable<double>(),
                                TiempoDeRetenciónEnArchivoGeneral = canConverttrg == true ? Convert.ToDouble(splitedLine[4]) : new Nullable<double>(),
                                DisposiciónFinal = new List<string>(),
                                Legislación = splitedLine[9] == null ? string.Empty : splitedLine[9],
                                Serie = relatedParentEntity
                            };
                            if (String.IsNullOrEmpty(entity.Title))
                            {
                                error.Append(string.Format("El nombre de la subserie no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }
                            if (String.IsNullOrEmpty(entity.Código))
                            {
                                error.Append(string.Format("El codigo de la subserie no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }
                            

                            if (String.IsNullOrEmpty(entity.Legislación))
                            {
                                error.Append(string.Format("La legislación de la subserie no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }

                            if (ctx.Subseries.Count(subserie => subserie.Title.Equals(entity.Title)) > 0)
                            {
                                error.Append(string.Format("Ya existe una subserie con el nombre {0}, (fila {1})<br/>", entity.Title, index));
                                iterationOk = false;
                            }
                            
                            if (loadedElements.Count(subserie => subserie.Title.Equals(entity.Title)) > 0)
                            {
                                error.Append(string.Format("Ya existe una subserie con el nombre {0} en el documento (fila {1})<br/>"
                                    , entity.Title, index));
                                iterationOk = false;
                            }


                            if (ctx.Subseries.Count(subserie => subserie.Código.Equals(entity.Código)) > 0)
                            {
                                error.Append(string.Format("Ya existe una subserie con el código {0}, (fila {1})<br/>", entity.Código, index));
                                iterationOk = false;
                            }
                            
                            if (loadedElements.Count(subserie => subserie.Código.Equals(entity.Código)) > 0)
                            {
                                error.Append(string.Format("Ya existe una subserie con el nombre {0} en el documento (fila {1})<br/>"
                                    , entity.Código, index));
                                iterationOk = false;
                            }

                            if (!string.IsNullOrEmpty(splitedLine[5])) { entity.DisposiciónFinal.Add("Conservar"); }
                            if (!string.IsNullOrEmpty(splitedLine[6])) { entity.DisposiciónFinal.Add("Medio Técnico"); }
                            if (!string.IsNullOrEmpty(splitedLine[7])) { entity.DisposiciónFinal.Add("Eliminar"); }
                            if (!string.IsNullOrEmpty(splitedLine[8])) { entity.DisposiciónFinal.Add("Seleccionar"); }
                            if (entity.DisposiciónFinal.Count <= 0)
                            {
                                error.Append(string.Format("La disposición final de la subserie no puede ser vacio, (fila {0})<br/>", index));
                                iterationOk = false;
                            }
                            if (iterationOk)
                            {
                                loadedElements.Add(entity);
                                ctx.Subseries.InsertOnSubmit(entity);
                                ctx.SubmitChanges();
                            }
                        }
                        else { error.Append(string.Format("El formato del archivo es inválido. Error en la fila {0}<br/>", index)); }
                        index++;
                    }
                }
            }
            return error.ToString();
        }

        public static string LoadPeopleFileIntoContactList(System.IO.Stream fileStream, char[] separator)
        {
            List<Personas> loadedElements = new List<Personas>();
            string currentLine = string.Empty;
            int index = 1;
            bool iterationOk;
            StringBuilder error = new StringBuilder();
            RegexHelper regHelper = new RegexHelper();

            using (DataContext ctx = new DataContext(SPContext.Current.Web.Url))
            {
                Microsoft.SharePoint.Linq.EntityList<Personas> contactList = ctx.GetList<Personas>("Contactos Externos");
                using (System.IO.StreamReader reader = new System.IO.StreamReader(fileStream,Encoding.Default))
                {
                    //reader.ReadLine();
                    while (!reader.EndOfStream)
                    {
                        iterationOk = true;
                        currentLine = reader.ReadLine();
                        string[] splitedLine = currentLine.Split(separator);

                        if (splitedLine.Length == 7)
                        {

                            if (index == 1)
                            {
                                if (splitedLine[0] != GlobalConstants.CAR_CONTACTOS_DOCS_PERSONAS_CEDULA || splitedLine[1] != GlobalConstants.CAR_CONTACTOS_DOCS_PERSONAS_NOMBRES
                                    || splitedLine[2] != GlobalConstants.CAR_CONTACTOS_DOCS_PERSONAS_PAPELLIDO || splitedLine[3] != GlobalConstants.CAR_CONTACTOS_DOCS_PERSONAS_SAPELLIDO
                                    || splitedLine[4] != GlobalConstants.CAR_CONTACTOS_DOCS_PERSONAS_DIRECCION || splitedLine[5] != GlobalConstants.CAR_CONTACTOS_DOCS_PERSONAS_TELEFONO
                                    || splitedLine[6] != GlobalConstants.CAR_CONTACTOS_DOCS_PERSONAS_EMAIL)
                                {
                                    error.Append(string.Format("El formato del archivo es inválido.El nombre de las columnas no corresponde al formato, Error en la fila {0}<br/>", index));
                                    break;
                                }
                            }
                            else
                            {
                                Personas entity = new Personas
                                {
                                    Title = string.Format("{0} {1} {2}", splitedLine[1], splitedLine[2], splitedLine[3]),
                                    ID = splitedLine[0],
                                    Nombres = splitedLine[1] == null ? string.Empty : splitedLine[1],
                                    PrimerApellido = splitedLine[2] == null ? string.Empty : splitedLine[2],
                                    SegundoApellido = splitedLine[3] == null ? string.Empty : splitedLine[3],
                                    Dirección = splitedLine[4] == null ? string.Empty : splitedLine[4],
                                    Teléfono = splitedLine[5] == null ? string.Empty : splitedLine[5],
                                    Email = splitedLine[6] == null ? string.Empty : splitedLine[6],
                                    TipoDeContacto = "Ciudadano"
                                };

                                if (String.IsNullOrEmpty(entity.ID))
                                {
                                    error.Append(string.Format("La cedula del contacto no puede ser vacio, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }
                                if (String.IsNullOrEmpty(entity.Nombres))
                                {
                                    error.Append(string.Format("El nombre del contacto no puede ser vacio, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }
                                if (String.IsNullOrEmpty(entity.PrimerApellido))
                                {
                                    error.Append(string.Format("El primer apellido del contacto no puede ser vacio, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }
                                if (String.IsNullOrEmpty(entity.Dirección))
                                {
                                    error.Append(string.Format("La direccion del contacto no puede ser vacio, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }


                                long telefono = 0;
                                bool canConvert = long.TryParse(entity.Teléfono, out telefono);
                                if (canConvert != true)
                                {
                                    error.Append(string.Format("El formato del telefono es incorrecto, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }

                                //if (!String.IsNullOrEmpty(entity.SegundoApellido))
                                //    if (contactList.Count(contact =>
                                //        (contact.Nombres.Equals(entity.Nombres)) &&
                                //        contact.PrimerApellido.Equals(entity.PrimerApellido) &&
                                //        contact.SegundoApellido.Equals(entity.SegundoApellido)) > 0)
                                //    {
                                //        error.Append(string.Format("Ya existe un contacto con nombres {0}, primer apellido {1}, segundo apellido {2} (fila {3})<br/>"
                                //            , entity.Nombres, entity.PrimerApellido, entity.SegundoApellido, index));
                                //        iterationOk = false;
                                //    }
                                if (!regHelper.IsValidEmail(entity.Email)) {
                                    error.Append(string.Format("El correo {0} no posee un formato correcto (fila {1})<br/>"
                                        , entity.Email, index));
                                    iterationOk = false;
                                }

                                if (contactList.Where(contact => contact.Email !=null).Count(contacts => contacts.Email.Equals(entity.Email)) > 0)
                                {
                                    error.Append(string.Format("Ya existe un contacto con correo eletrónico {0} (fila {1})<br/>"
                                        , entity.Email, index));
                                    iterationOk = false;
                                }

                                if (loadedElements.Where(contact => contact.Email != null).Count(contact => contact.Email.Equals(entity.Email)) > 0)
                                {
                                    error.Append(string.Format("Ya existe un contacto con correo eletrónico {0} en el documento (fila {1})<br/>"
                                        , entity.Email, index));
                                    iterationOk = false;
                                }

                                if (contactList.Count(contact => contact.ID.Equals(entity.ID)) > 0)
                                {
                                    error.Append(string.Format("Ya existe un contacto con cédula {0} (fila {1})<br/>"
                                        , entity.ID, index));
                                    iterationOk = false;
                                }

                                if (loadedElements.Count(contact => contact.ID.Equals(entity.ID)) > 0)
                                {
                                    error.Append(string.Format("Ya existe un contacto con cédula {0} (fila {1}) en el documento<br/>"
                                        , entity.ID, index));
                                    iterationOk = false;
                                }
                                
                                if (iterationOk) { loadedElements.Add(entity); }
                            }
                        }
                        else { error.Append(string.Format("El formato del archivo es inválido. Error en la fila {0}<br/>", index)); }
                        index++;
                    }
                }
                if (loadedElements.Count > 0)
                {
                    contactList.InsertAllOnSubmit(loadedElements);
                    ctx.SubmitChanges();
                }
            }
            return error.ToString();
        }

        public static string LoadEntitiesFileIntoContactList(System.IO.Stream fileStream, char[] separator)
        {
            List<Entidades> loadedElements = new List<Entidades>();
            string currentLine = string.Empty;
            int index = 1;
            bool iterationOk;
            RegexHelper regHelper = new RegexHelper();
            StringBuilder error = new StringBuilder();

            using (DataContext ctx = new DataContext(SPContext.Current.Web.Url))
            {
                Microsoft.SharePoint.Linq.EntityList<Entidades> contactList = ctx.GetList<Entidades>("Contactos Externos");
                using (System.IO.StreamReader reader = new System.IO.StreamReader(fileStream,UnicodeEncoding.Default))
                {
                    //reader.ReadLine();
                    while (!reader.EndOfStream)
                    {
                        iterationOk = true;
                        currentLine = reader.ReadLine();
                        string[] splitedLine = currentLine.Split(separator);
                       
                        if (splitedLine.Length == 7)
                        {
                            if (index == 1)
                            {
                                if (splitedLine[0] != GlobalConstants.CAR_CONTACTOS_DOCS_ENTIDADES_NIT || splitedLine[1] != GlobalConstants.CAR_CONTACTOS_DOCS_ENTIDADES_RAZON_SOCIAL
                                    || splitedLine[2] != GlobalConstants.CAR_CONTACTOS_DOCS_ENTIDADES_REPRESENTANTE || splitedLine[3] != GlobalConstants.CAR_CONTACTOS_DOCS_ENTIDADES_SIGLAS
                                    || splitedLine[4] != GlobalConstants.CAR_CONTACTOS_DOCS_ENTIDADES_DIRECCION || splitedLine[5] != GlobalConstants.CAR_CONTACTOS_DOCS_ENTIDADES_TELEFONO || splitedLine[6] != GlobalConstants.CAR_CONTACTOS_DOCS_ENTIDADES_EMAIL)
                                {
                                    error.Append(string.Format("El formato del archivo es inválido.El nombre de las columnas no corresponde al formato, Error en la fila {0}<br/>", index));
                                    break;
                                }
                            }
                            else
                            {
                                Entidades entity = new Entidades
                                {
                                    Title = splitedLine[1],
                                    ID = splitedLine[0],
                                    RazónSocial = splitedLine[1] == null ? string.Empty : splitedLine[1],
                                    Representante = splitedLine[2] == null ? string.Empty : splitedLine[2],
                                    Sigla = splitedLine[3] == null ? string.Empty : splitedLine[3],
                                    Dirección = splitedLine[4] == null ? string.Empty : splitedLine[4],
                                    Teléfono = splitedLine[5] == null ? string.Empty : splitedLine[5],
                                    Email = splitedLine[6] == null ? string.Empty : splitedLine[6],
                                    TipoDeContacto = "Entidad"
                                };
                                if (String.IsNullOrEmpty(entity.ID))
                                {
                                    error.Append(string.Format("El Nit del contacto no puede ser vacio, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }
                                if (String.IsNullOrEmpty(entity.RazónSocial))
                                {
                                    error.Append(string.Format("La razónSocial del contacto no puede ser vacio, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }
                                if (String.IsNullOrEmpty(entity.Representante))
                                {
                                    error.Append(string.Format("El representante del contacto no puede ser vacio, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }
                                if (String.IsNullOrEmpty(entity.Dirección))
                                {
                                    error.Append(string.Format("La direccion del contacto no puede ser vacio, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }
                                long telefono = 0;
                                bool canConvert = long.TryParse(entity.Teléfono, out telefono);
                                if (canConvert != true)
                                {
                                    error.Append(string.Format("El formato del telefono es incorrecto, (fila {0})<br/>", index));
                                    iterationOk = false;
                                }

                                if (contactList.Count(contact =>
                                    contact.RazónSocial.Equals(entity.RazónSocial)) > 0)
                                {
                                    error.Append(string.Format("Ya existe un contacto con razón social {0} (fila {1})<br/>"
                                        , entity.RazónSocial, index));
                                    iterationOk = false;
                                }

                                if (loadedElements.Count(contact => contact.RazónSocial.Equals(entity.RazónSocial)) > 0)
                                {
                                    error.Append(string.Format("Ya existe un contacto con razón social {0} (fila {1}) en el documento<br/>"
                                        , entity.RazónSocial, index));
                                    iterationOk = false;
                                }

                                if (contactList.Count(contact =>
                                    contact.ID.Equals(entity.ID)) > 0)
                                {
                                    error.Append(string.Format("Ya existe un contacto con Nit {0} (fila {1})<br/>"
                                        , entity.ID, index));
                                    iterationOk = false;
                                }

                                if (loadedElements.Count(contact => contact.ID.Equals(entity.ID)) > 0)
                                {
                                    error.Append(string.Format("Ya existe un contacto con Nit {0} (fila {1}) en el documento<br/>"
                                        , entity.ID, index));
                                    iterationOk = false;
                                }

                                if (contactList.Where(contact => contact.Email != null).Count(contact =>
                                    contact.Email.Equals(entity.Email)) > 0)
                                {
                                    error.Append(string.Format("Ya existe un contacto con correo electrónico {0} (fila {1})<br/>"
                                        , entity.Email, index));
                                    iterationOk = false;
                                }

                                if (!string.IsNullOrEmpty(entity.Email))
                                if (!regHelper.IsValidEmail(entity.Email))
                                {
                                    error.Append(string.Format("El correo {0} no posee un formato correcto (fila {1})<br/>"
                                        , entity.Email, index));
                                    iterationOk = false;
                                }

                                if (loadedElements.Where(contact => contact.Email != null).Count(contact => contact.Email.Equals(entity.Email)) > 0)
                                {
                                    error.Append(string.Format("Ya existe un contacto con correo electrónico {0} (fila {1}) en el documento<br/>"
                                        , entity.Email, index));
                                    iterationOk = false;
                                }

                                if (iterationOk) { loadedElements.Add(entity); }
                            }
                        }
                        else { error.Append(string.Format("El formato del archivo es inválido. Error en la fila {0}<br/>", index)); }
                        index++;
                    }
                }
                if (loadedElements.Count > 0)
                {
                    contactList.InsertAllOnSubmit(loadedElements);
                    ctx.SubmitChanges();
                }
            }
            return error.ToString();
        }

        private static void AddSection(string title, string code, SPListItem parentItem, int userID, SPList targetList)
        {
            SPContext.Current.Web.AllowUnsafeUpdates = true;
            SPListItem item = targetList.AddItem();
            item[SPBuiltInFieldId.Title] = title.ToUpper();
            item[CustomSiteColumns.FIELD_CODE] = code.ToUpper();
            item[CustomSiteColumns.FIELD_USER_IN_CHARGE] = new SPFieldUserValue { LookupId = userID };
            item[CustomSiteColumns.FIELD_SECCION_PADRE_INTERNAL_NAME] = parentItem == null ? null : new SPFieldLookupValue { LookupId = parentItem.ID };
            item.Update();
            SPContext.Current.Web.AllowUnsafeUpdates = false;
        }

        private static SPListItem GetParent(string title, SPList targetList)
        {
            SPListItem parentItem = null;
            SPQuery query = new SPQuery();
            query.Query = string.Format("<Where><Eq><FieldRef Name='Title' /><Value Type='Text'>{0}</Value></Eq></Where>", title.ToUpper());
            SPListItemCollection foundItems = targetList.GetItems(query);
            if (foundItems.Count > 0) { parentItem = foundItems[0]; }
            return parentItem;
        }

        private static void AddBackdrop(string title, string code, string version, SPListItem parentItem, SPList targetList)
        {
            SPContext.Current.Web.AllowUnsafeUpdates = true;
            SPListItem item = targetList.AddItem();
            item[SPBuiltInFieldId.Title] = title.ToUpper();
            item[CustomSiteColumns.FIELD_CODE] = code.ToUpper();
            item[CustomSiteColumns.FIELD_BACKDROP_VERSION] = Convert.ToInt32(version);
            item[CustomSiteColumns.FIELD_BACKDROP_PARENT] = parentItem == null ? null : new SPFieldLookupValue { LookupId = parentItem.ID };
            item.Update();
            SPContext.Current.Web.AllowUnsafeUpdates = false;
        }
    }
}
